
function initUpdateQueue(fiber) {
    fiber.updateQueue = {
        shared: {
            pending: null
        }
    }
}

function createUpdate() {
    return {}
}

// 创建循环链表
function enqueueUpdate(fiber, update) {
    const updateQueue = fiber.updateQueue
    const shared = updateQueue.shared
    const currentPending = shared.pending
    if (currentPending === null) {
        // 初始化，当前的更新对象的next指向自身
        update.next = update
    } else {
        // 当前的更新对象的next指向上一个更新对象
        update.next = currentPending.next
        // currentPending.next指向最新的更新
        currentPending.next = update
    }
    // 把pending指向当前更新对象
    updateQueue.shared.pending = update 
}

// 处理跟新队列的过程
function processQueueUpdate(fiber) {
    const queue = fiber.updateQueue
    // 取出当前任务队列
    const pending = queue.shared.pending
    // 清空queue上任务队列
    queue.shared.pending = null

    // 当前的pending永远指向的是最后一个更新任务
    const lastPendingUpdate = pending
    // 最后一个pending.next永远指向第一个更新任务
    const firstPendingUpdate = lastPendingUpdate.next

    // 取出任务链表之后，断开循环链表，变成单链表
    lastPendingUpdate.next = null
    let newState = fiber.memoizedSatate
    let update = firstPendingUpdate
    while(update) {
        console.log(update.payload)
        newState = { ...newState, ...update.payload }
        update = update.next
    }
    fiber.memoizedSatate = newState
}

// =====以下代码是模拟创建更新队列和处理更新队列方法=====

// 模拟更新队列
const update1 = createUpdate()
update1.payload = { name: '更新任务1' }

const update2 = createUpdate()
update2.payload = { name: '更新任务2' }

const update3 = createUpdate()
update3.payload = { name: '更新任务3' }

const update4 = createUpdate()
update4.payload = { name: '更新任务4' }

// 模拟初始化fiber
const fiber = {
    memoizedSatate: {
        id: 1
    }
}
initUpdateQueue(fiber)

enqueueUpdate(fiber, update1)
enqueueUpdate(fiber, update2)
enqueueUpdate(fiber, update3)
enqueueUpdate(fiber, update4)

console.log(fiber)

// processQueueUpdate(fiber)

